/*
 * Utileria.java	
 *
 * Copyright 2008 Universidad Francisco de Paula Santander (UFPS).
 * Todos los Derechos Reservados. 
 * Creado el 07/10/08, 11:23:38 AM
 */

package com.ufps.cuatro.util;

import java.awt.Color;
import java.awt.Desktop;
import java.awt.Toolkit;
import java.awt.datatransfer.Clipboard;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.PrintWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.channels.FileChannel;
import java.util.ArrayList;
import java.util.Properties;
import java.util.Random;
import java.util.StringTokenizer;
import java.util.UUID;
import java.util.logging.Level;
import java.util.logging.LogManager;
import java.util.logging.Logger;

import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JDesktopPane;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JInternalFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTable;
import javax.swing.JTree;
import javax.swing.SpinnerNumberModel;
import javax.swing.UIManager;
import javax.swing.table.TableModel;
import javax.swing.tree.TreeCellRenderer;
import javax.swing.tree.TreeNode;

import com.ufps.cuatro.CuatroApp;
import com.ufps.cuatro.controlador.render.UtilRender;
import com.ufps.cuatro.modelo.analizador.UtilAnalizador;
import com.ufps.cuatro.modelo.biblioteca.BibliotecaTrabajo;
import com.ufps.cuatro.modelo.representacion.ObjetoConstructor;
import com.ufps.cuatro.modelo.representacion.ObjetoTipoDatoReflexion;
import com.ufps.cuatro.modelo.representacion.ParametroObjetoConstructor;
import com.ufps.cuatro.modelo.representacion.componente.ComponenteDistribuidorGenerador;
import com.ufps.cuatro.util.base.ComponenteBaseStandar;
import com.ufps.cuatro.util.constantes.ConstAcciones;
import com.ufps.cuatro.util.constantes.ConstArbol;
import com.ufps.cuatro.util.constantes.ConstCasos;
import com.ufps.cuatro.util.constantes.ConstDistribucionDesplazamiento;
import com.ufps.cuatro.util.constantes.ConstGlobales;
import com.ufps.cuatro.util.constantes.ConstGridBagLayout;
import com.ufps.cuatro.util.constantes.ConstIconos;
import com.ufps.cuatro.util.constantes.ConstLimites;
import com.ufps.cuatro.util.constantes.ConstOpciones;
import com.ufps.cuatro.util.constantes.ConstRecursos;
import com.ufps.cuatro.util.constantes.ConstSeleccion;
import com.ufps.cuatro.util.constantes.ConstSizeIconos;
import com.ufps.cuatro.util.opciones.MyPreferences;
import com.ufps.cuatro.util.opciones.MyProperties;
import com.ufps.cuatro.util.opciones.UtilOpciones;
import com.ufps.cuatro.util.serializacion.TipoProcesoSerializado;
import com.ufps.cuatro.vistas.util.JDialogPopupHelpInfo;
import java.io.BufferedInputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
import javax.swing.event.InternalFrameAdapter;
import javax.swing.event.InternalFrameEvent;


/**
 * <i><b>Utileria:</b></i> Es una Clase en la cual se han hecho
 * definiciones para propositos generales. 
 * 
 * @author  Carlos A. Torres C. - Dolly E. Guerrero. <https://code.google.com/p/tesis4dor/>
 * @version 1.0 07/10/08 
 * @see ConstIconos
 * @see ConstCasos
 * @see ConstArbol
 * @see ConstSeleccion
 * @see ConstSizeIconos
 * @see ConstLimites
 * @see ConstAcciones
 * @see ConstGlobales
 * @see ConstRecursos
 * @see ConstDistribucionDesplazamiento
 */
public abstract class Utileria extends UtileriaBase implements ConstIconos, ConstCasos, ConstArbol,
    ConstSeleccion, ConstSizeIconos, ConstLimites, ConstAcciones, ConstGlobales,
    ConstRecursos, ConstDistribucionDesplazamiento, ConstGridBagLayout, ConstOpciones{
    
    /**
     *@DefinicionAtributo
     */
    public final static int MODO_PROPIEDADES = 0;
    /**
     * @DefinicionAtributo
     */
    public final static int MODO_OYENTES = 1;
    /**
     * @DefinicionAtributo
     */
    public final static int MODO_PLANTILLAS = 2;
    /**
     * @DefinicionAtributo
     */
    public final static int MODO_EXTRAS = 3;
    /**
     * @DefinicionAtributo
     */
    public final static int MODO_TIPOS = 3;

    /**
     * @DefinicionAtributo
     */
    public final static int JLABEL = 0;
    /**
     * @DefinicionAtributo
     */
    public final static int JBUTTON = 1;  
    
    
    
    /**
     * 
     */
    public static Color mix = Color.WHITE;

    

    /** Extension que representa el archivo index de cada análisis. */
    public static String extFile        = null;

    /** Extension que representa el archivo de la Fase 1 de cada análisis. */
    public static String extFileFase1   = null;

    /** Extension que representa el archivo de la Fase 2 de cada análisis. */
    public static String extFileFase2   = null;

    /** Extension que representa el archivo de la Fase 3 de cada análisis. */
    public static String extFileFase3   = null;

    /** Extension que representa el archivo de la Fase 4 de cada análisis. */
    public static String extFileFase4   = null;

    /** Titulo de la Aplicación. */
    public static String strTituloApp   = null;

    /** Titulo de la Aplicación. */
    public static String strPathIconoApp   = null;
         
    /** Cadena que representa la ruta de los recursos utilizados */
    public static String strPathBibliotecaDeRecursos            = null;
    /**
     * @DefinicionAtributo
     */
    public static String strPathBibliotecaDeRecursosIndice      = "Cuatro.properties";
    /**
     * @DefinicionAtributo
     */
    public static String strArchivoBibliotecaDeRecursosIndice   = "Indice.properties";

    /** Cadena que representa la ruta de los recursos utilizados en toda la Aplicación */
    public static String strPathBDRApp = null;

    /** Cadena que representa la ruta de los recursos utilizados en la fase 1 - analizador */
    public static String strPathBDRAnalizador = null;

    /** Cadena que representa la ruta de los recursos utilizados en la fase 2 - configurador */
    public static String strPathBDRConfigurador = null;

    /** Cadena que representa la ruta de los recursos utilizados en la fase 3 - intgrador */
    public static String strPathBDRIntegrador = null;

    /** Cadena que representa la ruta de los recursos utilizados en la fase 4 - generador */
    public static String strPathBDRGenerador = null;
      
    /** Ruta donde se almacenan los archivos que contienen las palabras reservadas */
    public static String strPathFile = null;

    /** Ruta principal donde se almacenan los iconos. */
    public static String strPathIconos = null;

    /** Ruta principal donde se almacenan los iconos Generales de la Aplicación. */
    public static String strPathIconosApp = null;

    /** Ruta principal donde se almacenan los iconos de la Fase 1. */
    public static String strPathIconosAnalizador = null;
    
    /** Ruta principal donde se almacenan los iconos de la Fase 2. */
    public static String strPathIconosConfigurador = null;
    
    /** Objeto de Propiedades General. */
    public static Properties objParametrosGenerales = null;

    /** Mantiene el Escritorio actual. */
    public static JDesktopPane objEscritorio = null;

    /** Almacena el Modo de Visualización de la GUI. */
    public static int modoGUI;

    /** Almacena la Cadena del  Modo de Visualización de la GUI. */
    public static String temaGUI;

     /** Información de la Linea actual de Procesamiento en Código. */
    public static int linea, llaves;   
    /**
     * @DefinicionAtributo
     */
    public static String strTempDir = "";
    /**
     * Cadena o ruta del Jar 
     */
    public static String strPathJar;
    /**
     * 
     */
    public static String strPathUser;
    /**
     * Archivo 
     */
    public static File objFileJar;       
    
    /**
     * 
     */
    public static ArrayList<String> objExceptionClass;
    /**
     * 
     */
    public static ArrayList<String> objExceptionPackage;
    
    /**
     * 
     */
    public static ArrayList<String> objTitulosArbolesPaquetes;
    /**
     * 
     */
    public static ArrayList<String> objTitulosArbolesCarpeta;
    /**
     * 
     */
    public static ArrayList<String> objTitulosArbolesGUI;
    
    /**
     * @DefinicionAtributo
     */
    public static ArrayList<MsgInfo> objMSG;
    
    /**
     * Variable static para almacenar los Recursos en las Subclases.
     */
    public static org.jdesktop.application.ResourceMap resourceMap;
    /**
     * 
     */
    public static Properties objRecursos;
    
    /**
     * 
     */
    public static JDialogPopupHelpInfo objDialogHelp = null;   
    /**
     * 
     */
    public static JFrame objFrame = null;
    
    /**
     *
     */
    public static String strUser;
    
    /**
     * Modo de Operación Normal.
     */
    public final static int ApplicationMode = 0;
    /**
     * Modo de Operación de Analisís de Modelos jar.
     */
    public final static int AnalysisMode    = 1;
    /**
     * Modo de Operación de Diseño de Intefaces Gráficas.
     */
    public final static int DesignMode      = 2;
    /**
     * Modo de Operación de Configruación de Propiedades de Controles.
     */
    public final static int PropertiesMode  = 3;
    /**
     * Modo de Operación de Configuración de la Aplicación.
     */
    public final static int SetupMode       = 4;
    /**
     * Modo de Operación de Generación de Vistas Previas.
     */
    public final static int ViewMode        = 5;
    /**
     * Modo de Operación de Generación de Código Fuente.
     */
    public final static int SourceCodeMode  = 6;
    
    /**
     * Indica el Modo de Operación de la Aplicacion.
     */
    private static int ExecuteMode;
    
    
    
    static{
        init();
    }
    
    private static void init(){
        try{
            resourceMap = org.jdesktop.application.Application.getInstance(CuatroApp.class).getContext().getResourceMap(Utileria.class);        
            //loadRecursos();
            objMSG                      = new ArrayList<MsgInfo>();
            objExceptionClass           = new ArrayList<String>();
            objExceptionPackage         = new ArrayList<String>();
            strPathUser                 = System.getProperty("user.home",".");
            strUser                     = System.getProperty("user.name");
            strTituloApp                = Utileria.leerRecursoTexto("Utileria.app.name");
            objTitulosArbolesPaquetes   = Utileria.getValuesProperties("Utileria.titulos.arbol.raiz.paquete");
            objTitulosArbolesCarpeta    = Utileria.getValuesProperties("Utileria.titulos.arbol.raiz.carpeta");
            objTitulosArbolesGUI        = Utileria.getValuesProperties("Utileria.titulos.arbol.raiz.gui");
            ExecuteMode                 = ApplicationMode;
        }catch(java.lang.Exception ex){
            UtilRender.printlnConsole("Incicalizacion de contexto Nulo en utileria.", UtilRender.ACTION_NORMAL, false); 
        }
    }
    
    
    
    /**
     * 
     */
    public static void initFrameApp(){
        try{
            objFrame = CuatroApp.getApplication().getMainFrame();
        }catch(java.lang.NullPointerException ex){
            UtilRender.printlnConsole("Incicalizacion de contexto Nulo en utileria.", UtilRender.ACTION_NORMAL, false); 
        }
    }
    
    /**
     * 
     */
    public static void loadRecursos(){
        try {
            objRecursos = new Properties();
            objRecursos.load(Utileria.class.getResourceAsStream("Utileria.properties"));            
        } catch (java.io.IOException ex) {
            objRecursos = null;
            UtilRender.printlnConsole("Recursos Utileria Nulo.", UtilRender.ACTION_NORMAL, false); 
        } catch (java.lang.NullPointerException ex) {
            objRecursos = null;
            UtilRender.printlnConsole("Recursos Utileria Nulo.", UtilRender.ACTION_NORMAL, false); 
        }
    }
    
    /**
     * Devuelve el Recurso de Texto Asociado a la Clave recibida en el Parametro ó
     * un Cadena vacia en Caso de no encontrarse ó presentarse un Error.
     * @param key Clave recibida.
     * @return Recurso de Texto Asociado a la Clave recibida en el Parametro.
     * @see org.jdesktop.application.ResourceMap#getString(java.lang.String, java.lang.Object[]) 
     * @throws java.lang.IllegalArgumentException
     */
    public static String leerRecursoTexto(String key){
        if(key != null && resourceMap != null){
            if(resourceMap.containsKey(key)){
                return resourceMap.getString(key);
            }
            else if(objRecursos != null){
                if(objRecursos.containsKey(key)){
                    return objRecursos.getProperty(key);
                }
            }
            else{
                UtilRender.printlnConsole("Administrador de Recursos Nulo.", UtilRender.ACTION_NORMAL, false);            
            }
        }
        else{
            UtilRender.printlnConsole("String Nulo.", UtilRender.ACTION_NORMAL, false);            
        }
        return "";
    }

    /**
     * Devuelve el Icono de la Aplicación de acuerdo  al tamaño recibido en el Parametro.
     * @param modo 
     * @return Icono de la Aplicación de acuerdo  al tamaño recibido en el Parametro.
     * @see org.jdesktop.application.ResourceMap#getIcon(java.lang.String) 
     * @throws java.lang.IllegalArgumentException
     */
    public static Icon leerIconoApp(int modo){
        if(resourceMap != null){
            String key = "Utileria.icono.app." + String.valueOf(modo);
            return resourceMap.getIcon(key);
        }
        else{
            UtilRender.printlnConsole("Adminsitrador de Recursos Nulo.", UtilRender.ACTION_NORMAL, false);            
        }
        return null;
    }

    /**
     * Devuelve el Icono de la Aplicación en Formato Imagen de acuerdo  al tamaño recibido en el Parametro.
     * @param modo 
     * @return Icono de la Aplicación en Formato Imagen de acuerdo  al tamaño recibido en el Parametro.
     * @see org.jdesktop.application.ResourceMap#getIcon(java.lang.String) 
     * @throws java.lang.IllegalArgumentException
     */
    public static ImageIcon leerIconoAppEnImagen(int modo){
        if(resourceMap != null){
            String key = "Utileria.icono.app." + String.valueOf(modo);
            return resourceMap.getImageIcon(key);
        }
        else{
            UtilRender.printlnConsole("Adminsitrador de Recursos Nulo.", UtilRender.ACTION_NORMAL, false);            
        }
        return null;
    }    
    
    /**
     * Devuelve el Recurso de Gráfico de Icono Asociado a la Clave y al Tamaño recibidos 
     * en los Parametros.
     * @param key Clave recibida.
     * @param size Tamaño del Icono.
     * @return Recurso de Gráfico de Icono Asociado a la Clave y al Tamaño recibidos 
     * en los Parametros.
     * @see org.jdesktop.application.ResourceMap#getIcon(java.lang.String) 
     * @throws java.lang.IllegalArgumentException
     */
    public static Icon leerRecursoIcono(String key, int size){
        if(resourceMap != null && key != null){
            String strPath = null;
            if(size == 16){
                strPath = key.replaceAll("32x32", "16x16");
            }
            else if(size == 32){
                strPath = key.replaceAll("16x16", "32x32");
            }            
            return resourceMap.getIcon(strPath);        
        }
        else{
            UtilRender.printlnConsole("Adminsitrador de Recursos Nulo.", UtilRender.ACTION_NORMAL, false);            
        }
        return null;
    }    
    
    /**
     * Devuelve el Recurso de Gráfico de Imagen Asociado a la Clave y al Tamaño recibidos 
     * en los Parametros.
     * @param key Clave recibida.
     * @param size Tamaño de la Imagen.
     * @return Recurso de Gráfico de Imagen Asociado a la Clave y al Tamaño recibidos 
     * en los Parametros.
     * @see org.jdesktop.application.ResourceMap#getIcon(java.lang.String) 
     * @throws java.lang.IllegalArgumentException
     */
    public static ImageIcon leerRecursoImagen(String key, int size){        
        if(resourceMap != null && key != null){
            String strPath = "";
            if(size == UtileriaBase.SIZE_ICON_16){
                strPath = key.replaceAll("32x32", "16x16");
            }
            else if(size == UtileriaBase.SIZE_ICON_32){
                strPath = key.replaceAll("16x16", "32x32");
            }        
            return resourceMap.getImageIcon(strPath);
        }
        else{
            UtilRender.printlnConsole("Adminsitrador de Recursos Nulo.", UtilRender.ACTION_NORMAL, false);            
        }
        return null;
    }
    
    /**
     * Carga un Archivo Properties en el formato válido de la Aplicación
     * para la administración de este tipo de archivo.
     * @param strPath Ruta de la Ubicación del Recurso.
     * @return Archivo Properties ecansulado en un objeto <code>MyProperties</code>.
     */
    public static MyProperties cargar(String strPath){        
        try {
            //URL url = resourceMap.getClassLoader().getResource(strPath);            
            if(strPath == null){
                return null;
            }
            else if(strPath.isEmpty()){
                return null;
            }
            else{
                InputStream in = resourceMap.getClassLoader().getResourceAsStream(strPath);
                MyProperties objPropiedades = new MyProperties(in);
                return objPropiedades;
            }
        } catch (java.io.IOException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } catch (java.lang.NullPointerException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        }
        return null;
    }       
    
    /**
     * Carga un Archivo Properties en el formato válido de la Aplicación
     * para la administración de este tipo de archivo.
     * @param objPath Ruta de la Ubicación del Recurso.
     * @return Archivo Properties ecansulado en un objeto <code>MyProperties</code>.
     */
    public static MyProperties cargarFileProperties(File objPath){
       if(objPath != null){
            try {            
                MyProperties objPropiedades = new MyProperties(objPath.toURI());
                return objPropiedades;
            } catch (java.io.IOException ex) {
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            } catch (java.lang.NullPointerException ex) {
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            }
            return null;
     }else{            
            UtilRender.printlnConsole("ObjPath Nulo.", UtilRender.ACTION_NORMAL, false); 
            return null;
        } 
    }
    
    /**
     * 
     */
    public static void runLog(){        
        try {
            if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_MSG_LOGGING, false)){
            
                String strPathConfigLog = Utileria.resourceMap.getResourcesDir() + 
                        Utileria.leerRecursoTexto("Utileria.log.config");            

                LogManager.getLogManager().readConfiguration(resourceMap.getClassLoader().getResourceAsStream(strPathConfigLog));
                System.out.println("Logging Configuration Loaded!!!. User Home: " + System.getProperty("user.home","."));                        
            }
        } catch (IOException ex){
            System.out.println("WARNING: Could not open configuration file");
            System.out.println("WARNING: Logging not configured (console output only)");
            System.out.println(ex.getMessage());
        } catch(SecurityException ex){
            System.out.println("WARNING: Not permission file");            
            System.out.println(ex.getMessage());
        }
    }    
    
    /**
     * @DefinicionMetodo
     * @param strPath @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static Properties cargarArchivoPropiedades(String strPath){
        Properties objPropiedades = new Properties(); 
        try{
            File objFilePaqueteSwing = new File(strPath);
            FileInputStream In = new FileInputStream(objFilePaqueteSwing);
            objPropiedades.load(In);
        }catch(FileNotFoundException e){
            System.out.println(e.getMessage());
            return null;
        }        
        catch(java.io.IOException ex){
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            return null;
        }
        return objPropiedades;
    }
    
    /**
     * @DefinicionMetodo
     * @param objTablaDistribucion @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean distribucionValida(javax.swing.JTable objTablaDistribucion){
        try{
            if(Utileria.objFrame != null){
                if(Utileria.matrizVacia(objTablaDistribucion)){
                    JOptionPane.showMessageDialog(
                            objTablaDistribucion,
                            "No se ha elegido una distribución para los elementos agregados.",
                            "",
                            JOptionPane.WARNING_MESSAGE
                            );            
                    return false;
                }
                else if(!Utileria.validarMatriz(objTablaDistribucion)){
                    JOptionPane.showMessageDialog(
                            objTablaDistribucion,
                            "La distribución ingresada no es válida.",
                            "",
                            JOptionPane.ERROR_MESSAGE
                            );            
                    return false;
                }           
                return true;
            }
        }catch(java.lang.NullPointerException ex){
            UtilRender.printlnConsole(ex.getMessage(), UtilRender.ACTION_ERROR, true);
        }
        return false;
    }
    
    /**
     *  @DefinicionMetodo
     * @param objTablaDistribucion @DefinicionParametro
     * @param size @DefinicionParametro
     */
    public static void generarMatriz(javax.swing.JTable objTablaDistribucion, int size){
        try{
            String[] TablaTitulos = new String[size];
            String[][] TablaDatos = new String[size][size];
            for(int i = 0; i < size; i++)
                TablaTitulos[i] = String.valueOf(i);
            javax.swing.JTable tabla = new javax.swing.JTable(TablaDatos,TablaTitulos);        
            objTablaDistribucion.setModel(tabla.getModel());
        }catch(java.lang.Exception ex){}
    }

    /**
     * @DefinicionMetodo
     * @param objTablaDistribucion @DefinicionParametro
     * @param filas @DefinicionParametro
     * @param columnas @DefinicionParametro
     */
    public static void generarMatriz(javax.swing.JTable objTablaDistribucion, int filas, int columnas){
        try{
            String[] TablaTitulos = new String[columnas];
            String[][] TablaDatos = new String[filas][columnas];
            for(int i = 0; i < columnas; i++)
                TablaTitulos[i] = String.valueOf(i);
            javax.swing.JTable tabla = new javax.swing.JTable(TablaDatos,TablaTitulos);
            objTablaDistribucion.setModel(tabla.getModel());
        }catch(java.lang.Exception ex){}
    }
    
    /**
     * @DefinicionMetodo
     * @param objTablaDistribucion @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean validarMatriz(javax.swing.JTable objTablaDistribucion){
        try{
            for(int i = 0; i < objTablaDistribucion.getRowCount() - 1; i++){
                for(int j = 0; j < objTablaDistribucion.getColumnCount() - 1; j++){
                     String strTemp1 = (String) objTablaDistribucion.getValueAt(j, i);
                     String strTemp2 = (String) objTablaDistribucion.getValueAt(j, i);
                    if(strTemp1 == null && strTemp2 != null)
                        return false;
                }
            }
            return true;
        }catch(java.lang.Exception ex){}
        return false;
    }
    
    /**
     * @DefinicionMetodo
     * @param objTablaDistribucion @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean matrizVacia(javax.swing.JTable objTablaDistribucion){
        try{
            for(int i = 0; i < objTablaDistribucion.getRowCount(); i++){
                for(int j = 0; j < objTablaDistribucion.getColumnCount(); j++){
                    String strTemp = (String) objTablaDistribucion.getValueAt(i, j);
                    if(strTemp != null)
                        if(!strTemp.isEmpty())
                            return false;                
                }
            }            
        }catch(java.lang.Exception ex){}
        return true;
    }
    
    /**
     * @DefinicionMetodo
     * @param objTablaDistribucion @DefinicionParametro
     * @param data @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean existeEnMatriz(javax.swing.JTable objTablaDistribucion, String data){
        try{
            for(int i = 0; i < objTablaDistribucion.getRowCount(); i++){
                for(int j = 0; j < objTablaDistribucion.getColumnCount(); j++){
                    String strTemp = (String) objTablaDistribucion.getValueAt(i, j);
                    if(strTemp != null)
                        if(!strTemp.isEmpty())
                            if(strTemp.equals(data))
                            return true;                
                }
            }
        }catch(java.lang.Exception ex){}
        return false;
    }
    
    /**
     * @DefinicionMetodo
     * @param objTablaDistribucion @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static int maxColumnUtilizadas(javax.swing.JTable objTablaDistribucion){
        try{
            int max = 1;
            for(int i = 0; i < objTablaDistribucion.getRowCount(); i++){
                int tempMax = 0;
                for(int j = 0; j < objTablaDistribucion.getColumnCount(); j++){
                    String strTemp = (String) objTablaDistribucion.getValueAt(i, j);
                    if(strTemp != null)
                        if(!strTemp.isEmpty())
                            tempMax++;
                }
                if(max < tempMax)max = tempMax;
            }
            return max;    
        }catch(java.lang.Exception ex){}
        return -1;
    }
    
    /**
     * @DefinicionMetodo
     * @param objTablaDistribucion @DefinicionParametro
     * @return @DefinicionReturnv
     */
    public static int maxRowUtilizadas(javax.swing.JTable objTablaDistribucion){
        try{
            int max = 1;
            for(int i = 0; i < objTablaDistribucion.getRowCount(); i++){
                int tempMax = 0;
                for(int j = 0; j < objTablaDistribucion.getColumnCount(); j++){
                    String strTemp = (String) objTablaDistribucion.getValueAt(j, i);
                    if(strTemp != null)
                        if(!strTemp.isEmpty())
                            tempMax++;
                }
                if(max < tempMax)max = tempMax;
            }
            return max;    
        }catch(java.lang.Exception ex){}
        return -1;
    }   
    
    /**
     * @DefinicionMetodo
     * @param objLista @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean existeSeleccion(JList objLista){
        try{
            if(Utileria.objFrame != null){
                if(objLista.isSelectionEmpty()){
                    JOptionPane.showMessageDialog(
                            objLista, 
                            "Lista Vacía",
                            "4Dor",
                            JOptionPane.WARNING_MESSAGE
                            );
                    return false;
                }
            }
        }catch(java.lang.NullPointerException ex){
            if(Utileria.objFrame != null){
                JOptionPane.showMessageDialog(
                        new JPanel(), 
                        "Lista Vacía",
                        "4Dor",
                        JOptionPane.WARNING_MESSAGE
                        );
                return false;
            }
            else{
                UtilRender.printlnConsole(ex.getMessage(), UtilRender.ACTION_ERROR, true);
            }
        }            
        return true;
    }  
        
    
    /**
     * @DefinicionMetodo
     * @param obj @DefinicionParametro
     * @param strMsg @DefinicionParametro
     * @param strTitulo @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean confirmarOrden(JComponent obj, String strMsg, String strTitulo){
        try{
            if(strMsg == null || obj == null){
                return false;
            }
            else if(strMsg.isEmpty()){
                return false;
            }
            int opc;
            if(strTitulo == null)
                strTitulo = Utileria.leerRecursoTexto("Utileria.app.name");
            else if(strTitulo.isEmpty())
                strTitulo = Utileria.leerRecursoTexto("Utileria.app.name");
            opc = JOptionPane.showConfirmDialog(obj,
                    strMsg,
                    strTitulo,
                    JOptionPane.YES_NO_OPTION,
                    JOptionPane.QUESTION_MESSAGE,
                    leerIconoApp(MODO_48x48));
            return (opc == JOptionPane.YES_OPTION);            
        }catch(java.lang.Exception ex){}
        return false;
    }
    
    /**
     * @DefinicionMetodo
@DefinicionParametro
     * @param strMsg @DefinicionParametro
     * @param strTitulo @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean confirmarOrden(String strMsg, String strTitulo){
        if(strMsg == null){
            return false;
        }
        else if(strMsg.isEmpty()){
            return false;
        }
        int opc;
        if(strTitulo == null){
            strTitulo = Utileria.leerRecursoTexto("Utileria.app.name");
        }
        else if(strTitulo.isEmpty()){
            strTitulo = Utileria.leerRecursoTexto("Utileria.app.name");
        }
        opc = JOptionPane.showConfirmDialog(objFrame, strMsg, strTitulo,
                JOptionPane.YES_NO_OPTION,
                JOptionPane.QUESTION_MESSAGE,
                leerIconoApp(MODO_48x48));
        return (opc == JOptionPane.YES_OPTION);
    }

    /**
     * @DefinicionMetodo
     * @param obj @DefinicionParametro
     * @param strMsg @DefinicionParametro
     * @param strTitulo @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean confirmarOrden(JFrame obj, String strMsg, String strTitulo){
        if(strMsg == null){
            return false;
        }
        else if(strMsg.isEmpty()){
            return false;
        }
        int opc;
        if(strTitulo == null)
            strTitulo = Utileria.leerRecursoTexto("Utileria.app.name");
        else if(strTitulo.isEmpty())
            strTitulo = Utileria.leerRecursoTexto("Utileria.app.name");
        opc = JOptionPane.showConfirmDialog(obj,
                strMsg,
                strTitulo,
                JOptionPane.YES_NO_OPTION,
                JOptionPane.QUESTION_MESSAGE,
                leerIconoApp(MODO_48x48));
        return (opc == JOptionPane.YES_OPTION);
    }
    
    /**
     * 
     * @param obj
     * @param strMsg
     * @param strTitulo
     * @return
     */
    public static boolean confirmarOrden(JDialog obj, String strMsg, String strTitulo){
        if(strMsg == null){
            return false;
        }
        else if(strMsg.isEmpty()){
            return false;
        }
        int opc;
        if(strTitulo == null)
            strTitulo = Utileria.leerRecursoTexto("Utileria.app.name");
        else if(strTitulo.isEmpty())
            strTitulo = Utileria.leerRecursoTexto("Utileria.app.name");
        opc = JOptionPane.showConfirmDialog(obj,
                strMsg,
                strTitulo,
                JOptionPane.YES_NO_OPTION,
                JOptionPane.QUESTION_MESSAGE,
                leerIconoApp(MODO_48x48));
        return (opc == JOptionPane.YES_OPTION);
    }
    
    /**
     * @DefinicionMetodo
     * @param obj @DefinicionParametro
     * @param strMsg @DefinicionParametro
     * @param strTitulo @DefinicionParametro
     * @param tipo @DefinicionParametro
     */
    public static void  mostrarMensaje(JFrame obj, String strMsg, String strTitulo,int tipo){        
        if(strMsg == null){
            return;
        }
        else if(strMsg.isEmpty()){
            return;
        }
        if(strTitulo == null)
            strTitulo = Utileria.leerRecursoTexto("Utileria.app.name");
        else if(strTitulo.isEmpty())
            strTitulo = Utileria.leerRecursoTexto("Utileria.app.name");
        JOptionPane.showMessageDialog(
            obj,
            strMsg,
            strTitulo,
            tipo,
            Utileria.leerIconoApp(Utileria.MODO_48x48));
    }
    
    /**
     * 
     * @param obj
     * @param strMsg
     * @param strTitulo
     * @param tipo
     */
    public static void  mostrarMensaje(JDialog obj, String strMsg, String strTitulo,int tipo){
        if(strMsg == null){
            return;
        }
        else if(strMsg.isEmpty()){
            return;
        }
        if(strTitulo == null)
            strTitulo = Utileria.leerRecursoTexto("Utileria.app.name");
        else if(strTitulo.isEmpty())
            strTitulo = Utileria.leerRecursoTexto("Utileria.app.name");
        JOptionPane.showMessageDialog(
            obj,
            strMsg,
            strTitulo,
            tipo,
            Utileria.leerIconoApp(Utileria.MODO_48x48));
    }

    /**
     * @DefinicionMetodo
     * @param obj @DefinicionParametro
     * @param strMsg @DefinicionParametro
     * @param strTitulo @DefinicionParametro
     * @param tipo @DefinicionParametro
     */
    public static void  mostrarMensaje(JComponent obj, String strMsg, String strTitulo,int tipo){
        if(strMsg == null){
            return;
        }
        else if(strMsg.isEmpty()){
            return;
        }
        if(obj == null)return;
        if(strTitulo == null){
            strTitulo = Utileria.leerRecursoTexto("Utileria.app.name");
        }
        else if(strTitulo.isEmpty()){
                strTitulo = Utileria.leerRecursoTexto("Utileria.app.name");
        }
        JOptionPane.showMessageDialog(
            obj,
            strMsg,
            strTitulo,
            tipo,
            Utileria.leerIconoApp(Utileria.MODO_48x48));        
    }   

    /**
     * @DefinicionMetodo
     * @param obj @DefinicionParametro
     * @param strMsg @DefinicionParametro
     * @param strTitulo  @DefinicionParametro
     * @param tipo @DefinicionParametro
     * @param modo @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static String  leerEntrada(JComponent obj, String strMsg, String strTitulo,int tipo, boolean modo){
        if(strMsg == null){
            return null;
        }
        else if(strMsg.isEmpty()){
            return null;
        }
        if(obj == null)return null;
        if(modo)//normal
            return JOptionPane.showInputDialog(
                obj,
                strMsg,
                strTitulo,
                tipo);
        else
            return JOptionPane.showInternalInputDialog(
                obj,
                strMsg,
                strTitulo,
                tipo);        
    }
    
    /**
     * @DefinicioMetodo
     * @param name  @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean esIdentificadorValido(String name){
        try{
            if(name.isEmpty())return false;
            if(Character.isJavaIdentifierStart(name.charAt(0)))
                for(int i = 0; i < name.length(); i++){                
                    if(!Character.isJavaIdentifierPart(name.charAt(i)))
                        return false;
                }
            return true;
        }catch(java.lang.NullPointerException ex){
             Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        }catch(java.lang.ArrayIndexOutOfBoundsException ex){
             Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        }
        return false;
    }
            
    /**
     * @DefinicionMetodo
     * @param objPathFile @DefinicionParametro
     * @param objAnalisis @DefinicionParametro
     * @return @DefinicionReturn
     */
//    public static boolean guardarAnalisis(File objPathFile, NuevoAnalisis objAnalisis){
//        String strFile = Utileria.eliminarExtension(objPathFile.getAbsolutePath());
//
//        String strFileFase = "";
//        String strFileExt = "." + Utileria.extFile;
//
//        FileWriter objFile = null;
//        BufferedWriter objBuffer = null;
//        PrintWriter objEscribir = null;
//
//        try {
//            objFile = new FileWriter(strFile + strFileExt);
//            objBuffer = new BufferedWriter(objFile);
//            objEscribir = new PrintWriter(objBuffer);
//
//            strFileExt = strFileExt.replaceFirst(".", ".1");
//            strFileFase = strFile + strFileExt;
//            guardarArchivoFase(strFileFase, objAnalisis.getSAnalizador());
//            objEscribir.println(Utileria.eliminarExtension(objPathFile.getName()) + strFileExt);
//
//            strFileExt = strFileExt.replaceFirst(".1", ".2");
//            strFileFase = strFile + strFileExt;
//            guardarArchivoFase(strFileFase, objAnalisis.getSConfigurador());
//            objEscribir.println(Utileria.eliminarExtension(objPathFile.getName()) + strFileExt);
//
//            strFileExt = strFileExt.replaceFirst(".2", ".3");
//            strFileFase = strFile + strFileExt;
//            guardarArchivoFase(strFileFase, objAnalisis.getSIntegrador());
//            objEscribir.println(Utileria.eliminarExtension(objPathFile.getName()) + strFileExt);
//
//            return true;
//        } catch (IOException ex) {
//            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
//        } finally {
//            objEscribir.close();
//        }
//        return false;
//    }
    
//    private static boolean guardarArchivoFase(String strPathFile, serializacionAnalizador sFase){
//        ObjectOutputStream objEscribir = null;
//        try {
//            objEscribir = new ObjectOutputStream(new FileOutputStream(strPathFile));
//            objEscribir.writeObject(sFase);
//            return true;
//        } catch (IOException ex) {
//            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
//        } finally {
//            try {
//                objEscribir.close();
//            } catch (IOException ex) {
//                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
//            }
//        }
//        return false;
//    }
//
//    private static boolean guardarArchivoFase(String strPathFile, serializacionConfigurador sFase){
//        ObjectOutputStream objEscribir = null;
//        try {
//            objEscribir = new ObjectOutputStream(new FileOutputStream(strPathFile));
//            objEscribir.writeObject(sFase);
//            return true;
//        } catch (IOException ex) {
//            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
//        } finally {
//            try {
//                objEscribir.close();
//            } catch (IOException ex) {
//                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
//            }
//        }
//        return false;
//    }
//
//    private static boolean guardarArchivoFase(String strPathFile, serializacionIntegrador sFase){
//        ObjectOutputStream objEscribir = null;
//        try {
//            objEscribir = new ObjectOutputStream(new FileOutputStream(strPathFile));
//            objEscribir.writeObject(sFase);
//            return true;
//        } catch (IOException ex) {
//            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
//        } finally {
//            try {
//                objEscribir.close();
//            } catch (IOException ex) {
//                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
//            }
//        }
//        return false;
//    }
    
    /**
     * @DefinicionMetodo
     * @param strPathFile @DefinicionParametro
     * @param objFile @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean guardarArchivoGenerico(String strPathFile, Object objFile){
        ObjectOutputStream objEscribir = null;
        if(objFile == null)return false;
        try {
            objEscribir = new ObjectOutputStream(new FileOutputStream(strPathFile));            
            objEscribir.writeObject(objFile);
            return true;
        } catch (IOException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } catch(java.lang.NullPointerException ex){
             Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            try {
                objEscribir.close();
            } catch (IOException ex) {
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            } catch(java.lang.NullPointerException ex){
                 Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return false;
    }        
    
    /**
     * 
     * @param strPathFile
     * @param strContenido
     * @return
     */
    public static boolean guardarArchivoTexto(String strPathFile, String strContenido){        
        PrintWriter writer = null;
        if(strContenido == null)return false;
        try {
            writer = new PrintWriter(new File(strPathFile));
            writer.print(strContenido);
            return true;
        } catch (IOException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } catch(java.lang.NullPointerException ex){
             Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            try{
                writer.close();            
            } catch(java.lang.NullPointerException ex){
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            }             
        }
        return false;
    }   
    
    /**
     * @DefinicionMetodo
     * @param strPath @DefinicionParametro
     * @param objBiblioteca @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static synchronized boolean guardarBiblioteca(String strPath, BibliotecaTrabajo objBiblioteca){
        ObjectOutputStream objEscribir = null;
        if(objBiblioteca == null)return false;
        //Utileria.clearClipboard();        
        try {
            strPath = UtilAnalizador.eliminarExtension(strPath);
            strPath += "." + Utileria.leerRecursoTexto("Utileria.file.lib.ext");
            objEscribir = new ObjectOutputStream(new FileOutputStream(strPath));
            objEscribir.writeObject(objBiblioteca);
            System.out.print("Biblioteca Almacenada en: " + strPath + " - " + objBiblioteca.toString());
            return true;
        } catch(java.io.NotSerializableException ex){
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } catch (java.lang.NullPointerException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        }
        finally {
            try {
                objEscribir.close();
            } catch (IOException ex) {
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            } catch (java.lang.NullPointerException ex) {
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return false;
    }      
    
    /**
     * @DefinicionMetodo
     * @param strPath @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static synchronized BibliotecaTrabajo cargarBiblioteca(String strPath){
        ObjectInputStream objLeer = null;
        if(strPath == null)return null;
        //Utileria.clearClipboard();        
        try {
            strPath = UtilAnalizador.eliminarExtension(strPath);
            strPath += "." + Utileria.leerRecursoTexto("Utileria.file.lib.ext");
            objLeer = new ObjectInputStream(new FileInputStream(strPath));
            BibliotecaTrabajo objBiblioteca = (BibliotecaTrabajo) objLeer.readObject();
            objBiblioteca.updateIdSerialComponentes();
            System.out.print("Biblioteca Cargada desde: " + strPath + " - " + objBiblioteca.toString());
            return objBiblioteca;
        } catch (FileNotFoundException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } catch (java.lang.NullPointerException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } finally {
            try {
                objLeer.close();
            } catch (IOException ex) {
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            } catch (java.lang.NullPointerException ex) {
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return null;
    }        

    /**
     * @DefinicionMetodo
     * @param strPath @DefinicionParametro
     * @param objComponente @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static synchronized boolean guardarComponente(String strPath, ComponenteDistribuidorGenerador objComponente){
        ObjectOutputStream objEscribir = null;                
        if(objComponente == null)return false;
        try {
            strPath = UtilAnalizador.eliminarExtension(strPath);
            strPath += "." + Utileria.leerRecursoTexto("Utileria.file.cog.ext");
            objEscribir = new ObjectOutputStream(new FileOutputStream(strPath));
            objEscribir.writeObject(objComponente);
            return true;
        } catch (IOException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } catch (java.lang.NullPointerException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        }
        finally {
            try {
                objEscribir.close();
            } catch (IOException ex) {
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            } catch (java.lang.NullPointerException ex) {
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return false;
    }

    /**
     * @DefinicionMetodo
     * @param strPath @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static synchronized ComponenteDistribuidorGenerador cargarComponente(String strPath){
        ObjectInputStream objLeer = null;
        if(strPath == null)return null;
        //Utileria.clearClipboard();        
        try {
            strPath = UtilAnalizador.eliminarExtension(strPath);
            strPath += "." + Utileria.leerRecursoTexto("Utileria.file.cog.ext");
            objLeer = new ObjectInputStream(new FileInputStream(strPath));
            ComponenteDistribuidorGenerador objComponente = (ComponenteDistribuidorGenerador) objLeer.readObject();
            return objComponente;
        } catch (FileNotFoundException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } catch (java.lang.NullPointerException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        }
        finally {
            try {
                objLeer.close();
            } catch (IOException ex) {
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            } catch (java.lang.NullPointerException ex) {
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return null;
    } 
    
    /**
     * @DefinicionMetodo
     * @return @DefinicionReturn
     */
    public static synchronized ArrayList<TipoProcesoSerializado> crearTrabajo(){
        ArrayList<TipoProcesoSerializado> objEProcesos = new ArrayList<TipoProcesoSerializado>();
        //Utileria.clearClipboard();
        if(Utileria.strTempDir != null){
            objEProcesos.add(TipoProcesoSerializado.eTempDir);
        }
        if(Utileria.strPathJar != null){
            objEProcesos.add(TipoProcesoSerializado.ePathJar);
        }
        if(Utileria.objFileJar != null){
            objEProcesos.add(TipoProcesoSerializado.eLoadJar);
        }        
        return objEProcesos;
    }     

    /**
     * @DefinicionMetodo
     * @param strPath @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean existeArchivo(String strPath){
        java.io.File objFile;
        objFile = new java.io.File(strPath);
        return objFile.exists();
    }        
    
    /**
     *@DefinicionMetodo
     * @param JArbol  @DefinicionParametro
     * @param objNodoRaiz @DefinicionParametro
     * @param JApariencia @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static synchronized boolean cargarJTree(JTree JArbol, TreeNode objNodoRaiz, TreeCellRenderer JApariencia){
      if(JArbol != null){
            try{
                JTree JTreeTemp = new JTree(objNodoRaiz);                 
                JArbol.setModel(JTreeTemp.getModel());
                JArbol.setCellRenderer(JApariencia); 
                return true;
            }catch(java.lang.Exception ex){
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            }
            return false;
     }else{            
            UtilRender.printlnConsole("Objeto Reflexión Nulo.", UtilRender.ACTION_NORMAL, false);
            return false;
        }
    }

    /**
     * @DefinicionMetodo
     * @param JArbol @DefinicionParametro
     * @param objNodoRaiz @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static synchronized boolean cargarJTree(JTree JArbol, TreeNode objNodoRaiz){
     if(JArbol != null && objNodoRaiz != null){
            try{
                JTree JTreeTemp = new JTree(objNodoRaiz);
                JArbol.setModel(JTreeTemp.getModel());
                return true;
            }catch(java.lang.Exception ex){
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            }
            return false;
    }else{            
            UtilRender.printlnConsole("Arbol o Nodo Nulo.", UtilRender.ACTION_NORMAL, false);
            return false;
        }
    }
    
    /**
     * @DefinicionMetodo
     * @param objElemento @DefinicionParametro
     * @param strPathFile @DefinicionParametro
     * @param Tipo @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static synchronized boolean cargarIcono(JComponent objElemento, String strPathFile, int Tipo){
       if(objElemento != null){
            try{
                JLabel jTemp = new JLabel(new ImageIcon(strPathFile));
                if(Tipo == Utileria.JLABEL){
                    JLabel objL = (JLabel) objElemento;
                    objL.setIcon(jTemp.getIcon());
                }
                else if(Tipo == Utileria.JBUTTON){
                    JButton objB = (JButton) objElemento;
                    objB.setIcon(jTemp.getIcon());
                }
                return true;
            }catch(java.lang.ClassCastException ex){
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            }catch(java.lang.NullPointerException ex){
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            }         
            return false;
        }else{            
            UtilRender.printlnConsole("Objeto Reflexión Nulo.", UtilRender.ACTION_NORMAL, false);   
            return false;
        }
    }
    
    /**
     * @DefinicionMetodo
     * @param modo @DefinicionParametro
     * @param panel @DefinicionParametro
     * @param frameInterno @DefinicionParametro
     * @param msgVentanaInterna @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static int confirmarCerrarVentana(boolean modo, JComponent panel, JInternalFrame frameInterno, String msgVentanaInterna){
        try{
            int valorRetorno = 0;
            String msgCerrar = "";
            String msgTitulo = "";
            
            if(panel == null || frameInterno == null){
                return -1;
            }
            
            if(!modo){//Ventana Interna
                msgCerrar = "";
                msgTitulo = "";

                if(!Utileria.confirmarOrden(frameInterno, msgCerrar, msgTitulo))
                    valorRetorno = JInternalFrame.DO_NOTHING_ON_CLOSE;
                else
                    valorRetorno = JInternalFrame.DISPOSE_ON_CLOSE;
            }
            else{//Ventana Principal
                msgCerrar = "";
                msgTitulo = "";

                if(!Utileria.confirmarOrden(panel, msgCerrar, msgTitulo))
                    valorRetorno = JFrame.DO_NOTHING_ON_CLOSE;
                else
                    valorRetorno = JFrame.DISPOSE_ON_CLOSE;
            }        
            return valorRetorno;
        }catch(java.lang.Exception ex){}
        return -1;
    }
        
    /**
     * @DefinicionMetodo
     * @param strCadena @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static int validarString(String strCadena){
        if(strCadena == null)return 1;
        else if(strCadena.isEmpty())return 2;
        return 0;
    }

    /**
     * @DefinicionMetodo
     * @param modo @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean cambiarApariencia(int modo){
        Utileria.modoGUI = modo;
        try {
            switch(modo){
                case 0://Modo Java
                    UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
                    break;
                case 1://Modo SO Local
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                    break;
                default://Modo Java
                    UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
            }
            return true;
        } catch (Exception ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);            
        }
        return false;
    }
    /**
     *@DefinicionMetodo
     * @param strTema @DefinicionParametro
     * @param modo @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean cambiarApariencia(String strTema, int modo){
       if(strTema != null && modo != 0){
            Utileria.modoGUI = modo;
            Utileria.temaGUI = strTema;
            try {
                UIManager.setLookAndFeel(strTema);            
            } catch (Exception ex) {
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);            
                return false;
            }
            return true;
       }
        else{            
            UtilRender.printlnConsole("Objeto Reflexión Nulo.", UtilRender.ACTION_NORMAL, false);            
            return false;
        }
        
}

    /**
     * @DefinicionMetodo
     * @param msg @DefinicionParametro
     * @param li @DefinicionParametro
     * @param size @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static String adaptarString(String msg, int li, int size){
        try{
            if(msg.length() > size)msg = msg.substring(li, size);
        }catch(java.lang.IndexOutOfBoundsException ex){
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        }
        return msg;
    }

    /**
     * @DefinicionMetodo
     * @param objFuente @DefinicionParametro
     * @param strRutaDestino @DefinicionParametro
     * @throws java.io.IOException @DefinicionParametro @DefinicionExcepcion
     */
    public static void copia(File objFuente, String strRutaDestino) throws IOException {
      if(objFuente != null && strRutaDestino != null){
        try{
            FileInputStream fis = new FileInputStream(objFuente);
            FileOutputStream fos = new FileOutputStream(strRutaDestino);
            FileChannel canalFuente = fis.getChannel();
            FileChannel canalDestino = fos.getChannel();
            canalFuente.transferTo(0, canalFuente.size(), canalDestino);
            fis.close();
            fos.close();
        } catch(java.io.IOException ex){
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } catch(java.lang.NullPointerException ex){
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        }        
    }else{            
            UtilRender.printlnConsole("Objeto Fuente o Destino Nulo.", UtilRender.ACTION_NORMAL, false);            
        }
    }

    /**
     * @DefinicionMetodo
     * @param objFuente @DefinicionParametro
     * @param objDestino @DefinicionParametro
     * @throws IOException @DefinicionExcepcion
     */
    public static void copia(File objFuente, File objDestino) throws IOException {
        if(objFuente != null && objDestino != null){  
            try{
                FileInputStream fis = new FileInputStream(objFuente);
                FileOutputStream fos = new FileOutputStream(objDestino);
                FileChannel canalFuente = fis.getChannel();
                FileChannel canalDestino = fos.getChannel();
                canalFuente.transferTo(0, canalFuente.size(), canalDestino);
                fis.close();
                fos.close();
            } catch(java.io.IOException ex){
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            } catch(java.lang.NullPointerException ex){
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            }         
        }else{ 
            UtilRender.printlnConsole("Objeto Fuente o Destino Nulo.", UtilRender.ACTION_NORMAL, false);            
        }
    }
    
    /**
     *
     * @param dir
     */
    public static void BorrarDirLocal(File dir) {         
        try{
            for(File f : dir.listFiles()) {
                if(f.isDirectory()) {
                    BorrarDirLocal(f);
                }
                if(f.isFile()){
                    if(!f.delete()) {
                        System.out.println("Error al borrar " + f.getName());
                    }
                }
            }
        }catch(SecurityException ex){
            UtilRender.printlnConsole("No se pudo eliminar el Proyecto generado anteriormente.", UtilRender.ACTION_ERROR, false);            
        }
    }
    /**
     * @DefinicionMetodo
     * @param strClassPath @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean esPosibleInstanciar(String strClassPath){
        if(strClassPath == null){
            return false;
        }
        if(UtilAnalizador.estaRegistradaEnElClassPath(strClassPath)){
            Class clase = null;
            Object objeto = null;
            try {
                // Cargamos la clase
                clase = Class.forName(strClassPath);
                objeto = clase.newInstance();
                return true;
            } catch (InstantiationException ex) {
                //Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            } catch (IllegalAccessException ex) {
                //Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            } catch (ClassNotFoundException ex) {
                //Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return false;
    }

    /**
     * @DefinicionMetodo
     * @param strClassPath @DefinicionParametro
     * @param modificador @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean evaluarModificador(String strClassPath, int modificador){
        if(strClassPath == null){
            return false;
        }
        if(UtilAnalizador.estaRegistradaEnElClassPath(strClassPath)){
            try {
                Class objClase = Class.forName(strClassPath);
                return Utileria.evaluarModificador(objClase, modificador);
            } catch (ClassNotFoundException ex) {
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return false;
    }
    
    /**
     *@DefinicionMetodo
     * @param objClass  @DefinicionParametro
     * @param modificador @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean isModificar(Class objClass, int modificador){
        try{
            return objClass.getModifiers() == modificador;
        }catch(java.lang.NullPointerException ex){}
        return false;
    }




    /**
     * @DefinicionMetodo
     * @param objClass @DefinicionParametro
     * @param modificador @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean evaluarModificador(Class objClass, int modificador){
        try{
            int m = objClass.getModifiers();
            switch(modificador){
                case java.lang.reflect.Modifier.ABSTRACT:
                    return java.lang.reflect.Modifier.isAbstract(m);
                case java.lang.reflect.Modifier.FINAL:
                    return java.lang.reflect.Modifier.isFinal(m);
                case java.lang.reflect.Modifier.INTERFACE:
                    return java.lang.reflect.Modifier.isInterface(m);
                case java.lang.reflect.Modifier.NATIVE:
                    return java.lang.reflect.Modifier.isNative(m);
                case java.lang.reflect.Modifier.PRIVATE:
                    return java.lang.reflect.Modifier.isPrivate(m);
                case java.lang.reflect.Modifier.PROTECTED:
                    return java.lang.reflect.Modifier.isProtected(m);
                case java.lang.reflect.Modifier.PUBLIC:
                    return java.lang.reflect.Modifier.isPublic(m);
                case java.lang.reflect.Modifier.STATIC:
                    return java.lang.reflect.Modifier.isStatic(m);
                case java.lang.reflect.Modifier.STRICT:
                    return java.lang.reflect.Modifier.isStrict(m);
                case java.lang.reflect.Modifier.SYNCHRONIZED:
                    return java.lang.reflect.Modifier.isSynchronized(m);
                case java.lang.reflect.Modifier.TRANSIENT:
                    return java.lang.reflect.Modifier.isTransient(m);
                case java.lang.reflect.Modifier.VOLATILE:
                    return java.lang.reflect.Modifier.isVolatile(m);
                default:
                    return objClass.isEnum();
            }
        }catch(java.lang.NullPointerException ex){}
        return false;
    }

    /**
     * @DefinicionMetodo
     * @param objClass @DefinicionParametro
     * @param modificador @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean evaluarModificador2(Class objClass, int modificador){
        try{
            int m = objClass.getModifiers();
            switch(modificador){
                case java.lang.reflect.Modifier.ABSTRACT:
                    return java.lang.reflect.Modifier.isAbstract(m);
                case java.lang.reflect.Modifier.FINAL:
                    return java.lang.reflect.Modifier.isFinal(m);
                case java.lang.reflect.Modifier.INTERFACE:
                    return java.lang.reflect.Modifier.isInterface(m);
                case java.lang.reflect.Modifier.NATIVE:
                    return java.lang.reflect.Modifier.isNative(m);
                case java.lang.reflect.Modifier.PRIVATE:
                    return java.lang.reflect.Modifier.isPrivate(m);
                case java.lang.reflect.Modifier.PROTECTED:
                    return java.lang.reflect.Modifier.isProtected(m);
                case java.lang.reflect.Modifier.PUBLIC:
                    return java.lang.reflect.Modifier.isPublic(m);
                case java.lang.reflect.Modifier.STATIC:
                    return java.lang.reflect.Modifier.isStatic(m);
                case java.lang.reflect.Modifier.STRICT:
                    return java.lang.reflect.Modifier.isStrict(m);
                case java.lang.reflect.Modifier.SYNCHRONIZED:
                    return java.lang.reflect.Modifier.isSynchronized(m);
                case java.lang.reflect.Modifier.TRANSIENT:
                    return java.lang.reflect.Modifier.isTransient(m);
                case java.lang.reflect.Modifier.VOLATILE:
                    return java.lang.reflect.Modifier.isVolatile(m);
                default:
                    return objClass.isEnum();
            }        
        }catch(java.lang.NullPointerException ex){}
        return false;
    }   

    /**
     * @DefinicionMetodo
     * @param strClassPath @DefinicionParametro
     * @param i @DefinicionParametro
     * @param args @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static synchronized Object crearInstancia(String strClassPath, int i, Object ... args){
        if(!strClassPath.isEmpty()){
            Class clase = null;
            Object objeto = null;
            Constructor constructor = null;
            Constructor[] constructores = null;
            try {
                // Cargamos la clase
                clase = Class.forName(strClassPath);
                constructores = clase.getConstructors();
                constructor = constructores[i];
                Class[] objParams = constructor.getParameterTypes();
                Object[] objValueParams = new Object[objParams.length];
                System.arraycopy(args, 0, objValueParams, 0, objParams.length);
                objeto = constructor.newInstance(objValueParams);
                return objeto;
            } catch (InstantiationException ex) {
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            } catch (IllegalAccessException ex) {
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            } catch (IllegalArgumentException ex) {
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            } catch (InvocationTargetException ex) {
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            } catch (ClassNotFoundException ex) {
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            } catch (java.lang.ArrayIndexOutOfBoundsException ex) {
                Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
            }
            return null;
        } else{            
            UtilRender.printlnConsole("ClassPath Nulo.", UtilRender.ACTION_NORMAL, false); 
            return null;
        }
    }
    
    /**
     * 
     * @param constructores
     * @param objConstructor
     * @return
     */
    public static synchronized Constructor getConstructorToConstructorBase(Constructor[] constructores, ObjetoConstructor objConstructor){        
        try{
            for(Constructor constructor : constructores){
                if(objConstructor.getObjParametros().size() == constructor.getParameterTypes().length){
                    for(int i = 0; i < constructor.getParameterTypes().length; i++){
                        Class parametro = constructor.getParameterTypes()[i];
                        ParametroObjetoConstructor objParametro = objConstructor.getObjParametros().get(i);
                        if(!parametro.getCanonicalName().equals(objParametro.getClasspath())){
                            break;
                        }
                    }
                    return constructor;
                }
            }
        }catch(java.lang.NullPointerException ex){}
        return null;
    }
    
    /**
     * @DefinicionMetodo
     * @param objComponenteBase  @DefinicionParametro
     * @param objConstructor  @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static synchronized Object crearInstancia(ComponenteBaseStandar objComponenteBase, ObjetoConstructor objConstructor){
      if(objComponenteBase != null){
        Class clase = null;
        Object objeto = null;
        Constructor constructor = null;
        Constructor[] constructores = null;
        try {
            // Cargamos la clase            
            clase = Class.forName(objComponenteBase.getStrClassPath());
            constructores = clase.getConstructors();
            //constructor = constructores[objConstructor.getOrden()];
            constructor = getConstructorToConstructorBase(constructores, objConstructor);
            Class[] objParams = constructor.getParameterTypes();
            Object[] objDefParams = new Object[objParams.length];
            Object[] objValueParams = objConstructor.getValoresParametros().toArray();
            if(objDefParams.length == objValueParams.length){
                System.arraycopy(objValueParams, 0, objDefParams, 0, objParams.length);
                objeto = constructor.newInstance(objDefParams);
            }
            else{
                objeto = clase.newInstance();
            }
            return objeto;
        } catch (InstantiationException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IllegalArgumentException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } catch (InvocationTargetException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } catch (java.lang.ArrayIndexOutOfBoundsException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } catch (java.lang.NullPointerException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        }
        return null;
    }else{            
            UtilRender.printlnConsole("Objeto Componente Base Nulo.", UtilRender.ACTION_NORMAL, false); 
            return null;
        }
    }

    /**
     * @DefinicionMetodo
     * @param objList @DefinicionParametro
     * @param objItem @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean existeEnLista(JList objList, Object objItem){
        try{
            int size = objList.getModel().getSize();
            for(int i = 0; i < size; i++)
                if(objList.getModel().getElementAt(i).equals(objItem))
                    return true;
            return false;
        }catch(java.lang.NullPointerException ex){}
        return false;
    }

    /**
     * @DefinicionMetodo
     * @param strToken @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean esIdentificadorJava(String strToken){
        try{
            if(strToken.isEmpty()){
                return false;
            }
            if(!Character.isJavaIdentifierStart(strToken.charAt(0))){
                return false;
            }
            else{
                for(int i = 1; i < strToken.length(); i++){
                    if(!Character.isJavaIdentifierPart(strToken.charAt(i))){
                        return false;
                    }
                }
                return true;                
            }
        }catch(java.lang.NullPointerException ex){}
        return false;
    }

    /**
     *@DefinicionMetodo
     * @param rangoMax @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static int randomInt(int rangoMax){
        double num = Math.random();
        int x = (int) (num * rangoMax + 1);
        return x;
    }   

    /**
     * @DefinicionMetodo
     * @return @DefinicionReturn
     */
    public static boolean clearClipboard(){
        Clipboard cb = Toolkit.getDefaultToolkit().getSystemClipboard();

        // Se obtiene el dato
        Transferable t = cb.getContents(null);
        if (t==null) return true;

        // Construimos el DataFlavor correspondiente a String.
        DataFlavor dataFlavorStringJava;
        try {
            dataFlavorStringJava = new DataFlavor("application/x-java-serialized-object; class=java.lang.String");
            // Si el dato se puede obtener como String, lo obtenemos y
            // lo
            // sacamos por la estándar out.
            if (t.isDataFlavorSupported(dataFlavorStringJava)) {
                String texto = (String) t
                        .getTransferData(dataFlavorStringJava);
                System.out.println(texto);
            }
            return true;
        } catch (UnsupportedFlavorException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        }
        return false;
    }

//    /**
//     * @DefinicionMetodo
//     * @param objSintaxis @DefinicionParametro
//     * @param key @DefinicionParametro
//     * @param formato @DefinicionParametro
//     * @return @DefinicionReturn
//     */
//    public static String getSrcCode(HashMap objSintaxis, String key, boolean formato){
//        LineaCodigo objSrc = new LineaCodigo();
//        objSrc = (LineaCodigo) objSintaxis.get(key);
//        String strSrc = formato ?  objSrc.getCodeFormateado() : objSrc.getCode();
//        strSrc = Utileria.identCode(strSrc) + "\n";
//        return strSrc;
//    }

    /**
     * @DefinicionMetodo
     * @param str @DefinicionParametro
     * @param c @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static int countChar(String str, char c){
        int count = 0;
        for(int i = 0; i < str.length(); i++){
            if(str.charAt(i) == c){
                count++;
            }
        }
        return count;
    }

    /**
     * @DefinicionMetodo
     * @param strSrc @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static String identCode(String strSrc){
        if(strSrc == null){
            return "";
        }
        else if(strSrc.isEmpty()){
            return "";
        }
        else{
            int modo = 0;
            if(strSrc.contains("{")){
                modo = 1;
                llaves++;
            }
            else if(strSrc.contains("}")){
                modo = 2;
                llaves--;
            }
            String tab = "";
            switch(modo){
                case 0://código sin llaves
                    for(int i = 0; i < llaves; i++)tab += "\t";
                    strSrc = tab + strSrc;
                    break;
                case 1://llave de incio
                    for(int i = 0; i < llaves - 1; i++)tab += "\t";
                    strSrc = tab + strSrc;
                    break;
                case 2://código sin llaves
                    for(int i = 0; i < llaves - 1; i++)tab += "\t";
                    strSrc = tab + strSrc;
                    break;
            }
            return strSrc;
        }
    }   

    /**
     * @DefinicionMetodo
     * @param strName @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static String getAlias(String strName){
        String strAlias = "";
        String strTemp = "";
        //esta funcion toma un nombre de una clase, atributo ó
        //método y devuelve el alias para representar en un jlabel
        if(!strName.isEmpty()){
            //primero se reemplaza todo caracter diferente a letras
            for(int i = 0; i < strName.length(); i++){
                if(Character.isLetterOrDigit(strName.charAt(0))){
                    strTemp += String.valueOf(strName.charAt(i));
                }
                else
                    strTemp += " ";
            }
            if(Character.isUpperCase(strTemp.charAt(0))){
                //el nombre inicia con mayuscula eso supone que el nombre
                //pertenece por lo general a un objeto
                //si este tiene un nombre compuesto entonces cada nombre
                //debe iniciar con Mayuscula y en ese momento se debe agregar
                //un espacio en blanco
                strAlias += String.valueOf(strTemp.charAt(0));
                for(int i = 1; i < strTemp.length(); i++){
                    if(Character.isLowerCase(strTemp.charAt(i))){
                        //copiar todas las minusculas pues representan un grupo
                        while(i < strTemp.length()){
                            if(Character.isLowerCase(strTemp.charAt(i))){
                                strAlias += String.valueOf(strTemp.charAt(i++));
                            }
                            else
                                break;
                        }
                        if(i < strTemp.length())
                            strAlias += " ";
                    }
                    if(i < strTemp.length())
                        if(Character.isUpperCase(strTemp.charAt(i))){
                            //copiar todas las minusculas pues representan un grupo
                            while(i < strTemp.length()){
                                if(Character.isLowerCase(strTemp.charAt(i))){
                                    strAlias += String.valueOf(strTemp.charAt(i++));
                                }
                                else
                                    break;
                            }
                        }
                }
                return strAlias;
            }
            else if(strTemp.startsWith("set") ||strTemp.startsWith("get")){
                //metodos de acceso a propiedades
                strAlias += String.valueOf(strTemp.charAt(3));
                for(int i = 4; i < strTemp.length(); i++){
                    if(Character.isLowerCase(strTemp.charAt(i))){
                        //copiar todas las minusculas pues representan un grupo
                        while(i < strTemp.length()){
                            if(Character.isLowerCase(strTemp.charAt(i))){
                                strAlias += String.valueOf(strTemp.charAt(i++));
                            }
                            else
                                break;
                        }
                        if(i < strTemp.length())
                            strAlias += " ";
                    }
                    if(i < strTemp.length())
                        if(Character.isUpperCase(strTemp.charAt(i))){
                            //copiar todas las minusculas pues representan un grupo
                            while(i < strTemp.length()){
                                if(Character.isLowerCase(strTemp.charAt(i))){
                                    strAlias += String.valueOf(strTemp.charAt(i++));
                                }
                                else
                                    break;
                            }
                        }
                }
                return strAlias;
            }
            else if(Character.isLowerCase(strTemp.charAt(0))){
                //el nombre inicia con minuscula eso supone que el nombre
                //pertenece por lo general a un metodo
                //el primer caracter se pone en mayusculas
                strAlias += String.valueOf(Character.toUpperCase(strTemp.charAt(0)));
                for(int i = 1; i < strTemp.length(); i++){
                    if(Character.isLowerCase(strTemp.charAt(i))){
                        //copiar todas las minusculas pues representan un grupo
                        while(i < strTemp.length()){
                            if(Character.isLowerCase(strTemp.charAt(i))){
                                strAlias += String.valueOf(strTemp.charAt(i++));
                            }
                            else
                                break;
                        }
                        if(i < strTemp.length())
                            strAlias += " ";
                        else
                            break;
                    }
                    if(i < strTemp.length())
                        if(Character.isUpperCase(strTemp.charAt(i))){
                            strAlias += String.valueOf(strTemp.charAt(i++));
                            //copiar todas las minusculas pues representan un grupo
                            while(i < strTemp.length()){
                                if(Character.isLowerCase(strTemp.charAt(i))){
                                    strAlias += String.valueOf(strTemp.charAt(i++));
                                }
                                else
                                    break;
                            }
                        }
                }
                return strAlias;
            }
        }
        return strName;
    }
    
    /**
     * @DefinicionMetodo
     * @param value @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static double getValueDouble(String value){
        try{
            double number = Double.parseDouble(value);
            return number;
        }catch(java.lang.NumberFormatException ex){
        }
        return -1;
    }

    /**
     *  @DefinicionMetodo
     * @param value @DefinicionParametro
     * @param value_default @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static double getValueDouble(String value, double value_default){
        try{
            double number = Double.parseDouble(value);
            return number;
        }catch(java.lang.NumberFormatException ex){
        }
        return value_default;
    }
    
    /**
     * @DefinicionMetodo
     * @param value @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static int getValueInteger(String value){
        try{
            int number = Integer.parseInt(value);
            return number;
        }catch(java.lang.NumberFormatException ex){
        }
        return -1;
    }

    /**
     *  @DefinicionMetodo
     * @param value @DefinicionParametro
     * @param value_default @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static int getValueInteger(String value, int value_default){
        try{
            int number = Integer.parseInt(value);
            return number;
        }catch(java.lang.NumberFormatException ex){
        }
        return value_default;
    }

    /**
     * @DefinicionMetodo
     * @param value @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean getValueBoolean(String value){
        try{
            boolean estado = Boolean.parseBoolean(value);
            return estado;
        }catch(java.lang.NumberFormatException ex){
        }
        return false;
    }
    
    /**
     * @DefinicionMetodo
     * @param value @DefinicionParametro
     * @param value_default @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static boolean getValueBoolean(String value, boolean value_default){
        try{
            boolean estado = Boolean.parseBoolean(value);
            return estado;
        }catch(java.lang.NumberFormatException ex){
        }
        return value_default;
    }

    /**
     * @DefinicionMetodo
     * @param value @DefinicionParametro
     * @param value_default @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static String getValueString(String value, String value_default){
        if(value == null)
            return value_default;
        else if(value.isEmpty())
            return value_default;
        return value;
    }
    
    /**
     * @DefinicionMetodo
     * @param value @DefinicionParametro
     * @param value_default @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static char getValueCharacter(String value, char value_default){
        try{
            char c = value.charAt(0);
            return c;
        }catch(java.lang.NumberFormatException ex){
        }
        return value_default;
    }
        
    /**
     * @DefinicionMetodo
     * @param eCaso @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static String getNombreCaso(TipoCaso eCaso){
        if(eCaso == null)return "No Disponible";
        if(eCaso == TipoCaso.ePrimitivo){
            return "Tipo Primtivo";
        }
        else if(eCaso == TipoCaso.eJDKRegistrado){
            return "JDK Registrado";
        }
        else if(eCaso == TipoCaso.eEnumeracion){
            return "Enumeración";
        }
        else if(eCaso == TipoCaso.eClaseMundo){
            return "Clase Mundo";
        }
        else if(eCaso == TipoCaso.eArray){
            return "Array";
        }
        else if(eCaso == TipoCaso.eJDKNoRegistrado){
            return "JDK No Registrado";
        }
        return eCaso.name();
    }

    /**
     * @DefinicionMetodo
     * @param eCaso @DefinicionParametro
     * @return  @DefinicionReturn
     */
    public static String getPathIconoCaso(TipoCaso eCaso){
        try{
            if(eCaso == TipoCaso.ePrimitivo){
                return Utileria.ICONO_PRIMITIVO;
            }
            else if(eCaso == TipoCaso.eArray){
                return Utileria.ICONO_ARRAY;
            }
            else if(eCaso == TipoCaso.eEnumeracion){
                return Utileria.ICONO_ENUMERACION;
            }
            else if(eCaso == TipoCaso.eJDKRegistrado){
                return Utileria.ICONO_JDK_REGISTRADO;
            }
            else if(eCaso == TipoCaso.eClaseMundo){
                return Utileria.ICONO_CLASE;
            }
            else {
                return Utileria.ICONO_JDK_NO_REGISTRADO;
            }
        }catch(java.lang.NullPointerException ex){}
        return null;
    }

    /**
     * @DefinicionMetodo
     * @param objTipoDato 
@DefinicionParametro
     * @return @DefinicionReturn
     */
    public static String getDescripcionCaso(ObjetoTipoDatoReflexion objTipoDato){
        if(objTipoDato == null)return "";
        if(objTipoDato.getObjCaso().isArray()){
            TipoCaso eCaso = objTipoDato.getObjCaso().getObjCasoInterno().geteCaso();
            if(eCaso == TipoCaso.ePrimitivo){
                return "<html><b>Array de</b> " + Utileria.leerRecursoTexto(Utileria.DESCRIPCION_CASO_PRIMITIVO) + "</html>";
            }
            else if(eCaso == TipoCaso.eArray){
                return "<html><b>Array de</b> " + Utileria.leerRecursoTexto(Utileria.DESCRIPCION_CASO_ARRAY) + "</html>";
            }
            else if(eCaso == TipoCaso.eEnumeracion){
                return "<html><b>Array de</b> " + Utileria.leerRecursoTexto(Utileria.DESCRIPCION_CASO_ENUM) + "</html>";
            }
            else if(eCaso == TipoCaso.eJDKRegistrado){
                return "<html><b>Array de</b> " + Utileria.leerRecursoTexto(Utileria.DESCRIPCION_CASO_JDK_REGISTRADO) + "</html>";
            }
            else if(eCaso == TipoCaso.eClaseMundo){
                return "<html><b>Array de</b> " + Utileria.leerRecursoTexto(Utileria.DESCRIPCION_CASO_CLASE_MUNDO) + "</html>";
            }
            else {
                return "<html><b>Array de</b> " + Utileria.leerRecursoTexto(Utileria.DESCRIPCION_CASO_JDK_NO_REGISTRADO) + "</html>";
            }
        }
        else{
            TipoCaso eCaso = objTipoDato.getObjCaso().geteCaso();
            if(eCaso == TipoCaso.ePrimitivo){
                return "<html>" + Utileria.leerRecursoTexto(Utileria.DESCRIPCION_CASO_PRIMITIVO) + "</html>";
            }
            else if(eCaso == TipoCaso.eArray){
                return "<html>" + Utileria.leerRecursoTexto(Utileria.DESCRIPCION_CASO_ARRAY) + "</html>";
            }
            else if(eCaso == TipoCaso.eEnumeracion){
                return "<html>" + Utileria.leerRecursoTexto(Utileria.DESCRIPCION_CASO_ENUM) + "</html>";
            }
            else if(eCaso == TipoCaso.eJDKRegistrado){
                return "<html>" + Utileria.leerRecursoTexto(Utileria.DESCRIPCION_CASO_JDK_REGISTRADO) + "</html>";
            }
            else if(eCaso == TipoCaso.eClaseMundo){
                return "<html>" + Utileria.leerRecursoTexto(Utileria.DESCRIPCION_CASO_CLASE_MUNDO) + "</html>";
            }
            else {
                return "<html>" + Utileria.leerRecursoTexto(Utileria.DESCRIPCION_CASO_JDK_NO_REGISTRADO) + "</html>";
            }
        }
    }

    /**
     *  @DefinicionMetodo
     * @param key @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static String getPathKeyToApp(String key){
        if(key == null)return "";
        try{
            return Utileria.strPathApp + Utileria.separador +  Utileria.leerRecursoTexto(key);
        }catch(java.lang.Exception ex){}
        return "";
    }       

    

    /**
     * @DefinicionMetodo
     * @param objPropiedades @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static TableModel getModel(MyProperties objPropiedades){
        if(objPropiedades == null)return null;
        int size = objPropiedades.getObjKey().size();
        String[] titulos = {"Identificador","Valor"};
        String[][] datos = new String[size][2];
        for(int i = 0; i < size; i ++){
            String key = objPropiedades.getObjKey().get(i);
            String value = objPropiedades.getObjValue().get(i);
            datos[i][0] = key;
            datos[i][1] = value;
        }
        JTable objTable = new JTable(datos, titulos);
        return objTable.getModel();

    }
    
    /**
     * 
     * @param ex
     * @param strTitulo
     */
    public static void encapsularMensajeExceptionOld(Exception ex, String strTitulo) {
        try{
            MsgInfo objErrorMsg = new MsgInfo();
            objErrorMsg.setFecha(new java.util.Date());
            objErrorMsg.setStrMSG(strTitulo);
            objErrorMsg.setStrMSGJava(ex.toString());
            objErrorMsg.setStrTitulo("Exception");
            objErrorMsg.setTipo(MsgInfo.ERROR);
            objErrorMsg.setVisualizado(false);
            Utileria.objMSG.add(objErrorMsg);
        }catch(java.lang.NullPointerException exs){}
    }
    
    /**
     * Determina si un Objeto es válido para usos especificos en la Aplicación.
     * Un Objeto es válido cuando cumple ciertos requerimientos por ejemplo:
     * Si se necesita evaluar un <code>String</code> como válido se evaluará
     * primero que no sea <code>null</code>, luego que la cadena este inicializada
     * es decir que no sea vacia. Este Método es utilizado para procesos concretos
     * por lo que su uso no debe ser generalizado, ya que algunas restricciones
     * podrían ser validas en otros casos.
     * @param obj Objeto que se evaluará.
     * @return Resultado de proceso que detemrina si el Objeto es válido.
     */
    public static boolean esValido(Object obj){
        if(obj instanceof String){
            String strObj = (String) obj;
            if(strObj == null)return false;
            return !strObj.isEmpty();
        }
        
        return false;
    }
    
    /**
     * @DefinicionMetodo
     * @param obj @DefinicionParametro
     * @param str @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static String formatStringComponente(Object obj, String str){
        String strFormat = "";
        if(obj instanceof Method){
            strFormat = Character.toUpperCase(str.charAt(0)) + str.substring(1);
        }
        return strFormat;
    }
    
    /**
     * 
     * @return
     */
    public static String getStringSerialUUID(){
        UUID uuid = UUID.randomUUID();
        return uuid.toString();
    }
    
    /**
     * 
     * @param objTempModel
     * @param fila
     * @param columna
     * @return
     */
    public static DistribucionGroupLayout getDistribucionHorizontal(TableModel objTempModel, int fila, int columna){
        if(objTempModel == null)return null;
        DistribucionGroupLayout objDistribuidor = new DistribucionGroupLayout();
        objDistribuidor.setIsDistribucion(true);//Horizontal
        for(int j = columna; j < objTempModel.getColumnCount(); j++){
            String strComponente = (String) objTempModel.getValueAt(fila, j);
            if(strComponente == null)continue;
            if(objDistribuidor.getStrComponentes().contains(strComponente))continue;
            if(Utileria.existeGrupoParalelo(objTempModel, strComponente, fila, j)){
                DistribucionGroupLayout objDistribuidorInterno =
                        Utileria.getDistribucionVertical(objTempModel, fila, j);
                if(!objDistribuidorInterno.getStrComponentes().isEmpty() || !objDistribuidorInterno.getObjElementos().isEmpty()){
                    objDistribuidor.getObjElementos().put(
                            TipoGrupoDistribucion.eParalelo, 
                            objDistribuidorInterno);
                }
            }
            objDistribuidor.addComponente(strComponente + " Secuencial" + fila);
        }           
        return objDistribuidor;
    }
    
    /**
     * 
     * @param objTempModel
     * @param fila
     * @param columna
     * @return
     */
    public static DistribucionGroupLayout getDistribucionVertical(TableModel objTempModel, int fila, int columna){
        if(objTempModel == null)return null;
        DistribucionGroupLayout objDistribuidor = new DistribucionGroupLayout();
        objDistribuidor.setIsDistribucion(false);//Vertical
        for(int i = fila; i < objTempModel.getColumnCount(); i++){
            String strComponente = (String) objTempModel.getValueAt(i, columna);
            if(strComponente == null)continue;
            if(objDistribuidor.getStrComponentes().contains(strComponente))continue;
            if(Utileria.existeGrupoSecuencial(objTempModel, strComponente, i, columna)){
                DistribucionGroupLayout objDistribuidorInterno =
                        Utileria.getDistribucionHorizontal(objTempModel, i, columna);
                if(!objDistribuidorInterno.getStrComponentes().isEmpty() || !objDistribuidorInterno.getObjElementos().isEmpty()){
                    objDistribuidor.getObjElementos().put(
                            TipoGrupoDistribucion.eSecuencial,
                            objDistribuidorInterno);
                }
            }
            objDistribuidor.addComponente(strComponente + " Grupo" + columna);
        }           
        return objDistribuidor;
    }
    
    /**
     * 
     * @param objTempModel
     * @param strComponente
     * @param fila
     * @param columna
     * @return
     */
    public static boolean existeGrupoParalelo(TableModel objTempModel, String strComponente,int fila, int columna){        
        if(objTempModel == null)return false;
        for(int i = fila + 1; i < objTempModel.getColumnCount(); i++){
            String strNextComponente = (String) objTempModel.getValueAt(i, columna);
            if(strNextComponente != null){
                return !strNextComponente.equals(strComponente);
            }
        }        
        return false;
    }
    
    /**
     * 
     * @param objTempModel
     * @param strComponente
     * @param fila
     * @param columna
     * @return
     */
    public static boolean existeGrupoSecuencial(TableModel objTempModel, String strComponente, int fila, int columna){        
        if(objTempModel == null)return false;
        for(int j = columna + 1; j < objTempModel.getRowCount(); j++){
            String strNextComponente = (String) objTempModel.getValueAt(fila, j);
            if(strNextComponente != null){
                return !strNextComponente.equals(strComponente);
            }
        }        
        return false;
    }
    
    /**
     * 
     * @return
     */
    public static SpinnerNumberModel getModelDefaultSpinnerIntegerGridBagConstraints(){
        return new SpinnerNumberModel(Utileria.MIN_INTEGER_RANGE, Utileria.MIN_INTEGER_RANGE, Utileria.MAX_INTEGER_RANGE, Utileria.STEP_INTEGER_RANGE);
    }
    
    /**
     * 
     * @return
     */
    public static SpinnerNumberModel getModelDefaultSpinnerDoubleGridBagConstraints(){
        return new SpinnerNumberModel(Utileria.MIN_DOUBLE_RANGE, Utileria.MIN_DOUBLE_RANGE, Utileria.MAX_DOUBLE_RANGE, Utileria.STEP_DOUBLE_RANGE);
    }
    
    /**
     * 
     * @return
     */
    public static Color generateRandomColor() {         
        Random random = new Random(); 
        int red = random.nextInt(256); 
        int green = random.nextInt(256); 
        int blue = random.nextInt(256); 
        // mix the color 
        if (mix != null) { 
            red = (red + mix.getRed()) / 2; 
            green = (green + mix.getGreen()) / 2; 
            blue = (blue + mix.getBlue()) / 2; 
        } 
        Color color = new Color(red, green, blue); 
        return color; 
    } 
    
    /**
     * 
     * @param strMSG
     */
    public static void viewConsole(String strMSG){
        if(strMSG == null)return;
        if(UtilOpciones.objPreferences.getBoolean(MyPreferences.BOOLEAN_APP_ACTIVAR_MSG_CONSOLA, true)){
            System.out.println(strMSG);
        }
    }
    
    /**
     * 
     * @param strValue
     * @param strExclusiones
     * @return
     */
    public static boolean evalInclusionInString(String strValue, String strExclusiones){                
        StringTokenizer objToken = new StringTokenizer(strExclusiones, " ,");       
        while(objToken.hasMoreElements()){
            String strToken = (String) objToken.nextElement();
            if(strValue.equalsIgnoreCase(strToken))return true;
        }
        return false;
    }

    /**
     * 
     * @param strIdentificador
     * @return
     */
    public static boolean esIdentificadorJavaValido(String strIdentificador){
        try{        
            if(strIdentificador.isEmpty())return false;
            if(!Character.isJavaIdentifierStart(strIdentificador.charAt(0))){
                Utileria.mostrarMensaje(CuatroApp.getApplication().getMainFrame(), "El Nombre del Paquete no Inicia con el Estandard java ej: cuatro.", "", JOptionPane.WARNING_MESSAGE);
                return false;
            }
            else{
                for(char c : strIdentificador.toCharArray()){
                    if(!Character.isJavaIdentifierPart(c)){
                        Utileria.mostrarMensaje(CuatroApp.getApplication().getMainFrame(), "El Nombre del Paquete no es valido con el Estandard java ej: cuatro.", "", JOptionPane.WARNING_MESSAGE);
                        return false;
                    }
                }
            }
            return true;
        }catch(java.lang.NullPointerException ex){}
        return false;
    }
    
    /**
     * 
     * @param strHtml
     * @return
     */
    public static boolean isFormatHTML(String strHtml){
        try{
            if(strHtml.startsWith("<html>") || strHtml.contains("</")){
                return true;
            }
        }catch(java.lang.NullPointerException ex){}
        return false;
    }
    
    /**
     * 
     * @param strHtml
     * @return
     */
    public static String formatStringSinHTML(String strHtml){
        try{
            if(strHtml.startsWith("<html>")){
                strHtml = strHtml.replaceAll("<html>", "");
                strHtml = strHtml.replaceAll("</html>", "");
                //strHtml = strHtml.replaceAll("html", "");
                //strHtml = strHtml.replaceAll("<", "");
                //strHtml = strHtml.replaceAll(">", "");
                //strHtml = strHtml.replaceFirst("/", "");
            }            
        }catch(java.lang.NullPointerException ex){}
        return strHtml;
    }
    
    /**
     * 
     * @param str
     * @return
     */
    public static String getKamelCaseCapital(String str){
        try{
            if(!str.isEmpty()){
                char c = str.charAt(0);
                c = Character.toUpperCase(c);
                String str2 = str.substring(1);
                return c + str2;
            }
        }catch(java.lang.Exception ex){}
        return str;
    }
    
    /**
     * 
     * @param str
     * @param capital
     * @return
     */
    public static String getKamelCase(String str, boolean capital){
        try{
            if(!str.isEmpty()){
                int j = 0;
                String temp = "";
                for(char c : str.toCharArray()){
                    //Primer caso se fomatea la primera letra a mayuscula
                    if(j == 0 && capital){
                        temp += String.valueOf(Character.toUpperCase(c));
                    }                    
                    else if(Character.isUpperCase(c)){//Mayuscula
                        temp += String.valueOf(Character.toUpperCase(c));
                    }
                    else{//Se asigna el caracter
                        temp += String.valueOf(c);
                    }
                    j++;
                }
                return temp;
            }
        }catch(java.lang.Exception ex){}
        return str;
    }
    
    /**
     * 
     * @param str
     * @param capital
     * @return
     */
    public static String getKamelCaseFormat(String str, boolean capital){
        try{
            if(!str.isEmpty()){
                int j = 0;
                String temp = "";
                for(char c : str.toCharArray()){
                    //Primer caso se fomatea la primera letra a mayuscula
                    if(j == 0 && capital){
                        temp += String.valueOf(Character.toUpperCase(c));
                    }                    
                    else if(Character.isSpaceChar(c)){//Barra Piso
                        temp += " ";
                    }
                    else if(Character.isUpperCase(c)){//Mayuscula
                        temp += " " + String.valueOf(Character.toUpperCase(c));
                    }
                    else{//Se asigna el caracter
                        temp += String.valueOf(c);
                    }
                    j++;
                }
                return temp;
            }
        }catch(java.lang.Exception ex){}
        return str;
    }
    
    /**
     * @DefinicionMetodo
     * @param key @DefinicionParametro
@DefinicionParametro
     * @return @DefinicionReturn
     */
    public static ArrayList<String> getValuesProperties(String key){
        if(key.isEmpty())return null;
        String values = Utileria.leerRecursoTexto(key);
        return getValuesPropertiesToken(values, ",");
    }
    
    /**
     * @DefinicionMetodo
@DefinicionParametro
     * @param values 
     * @param tokens @DefinicionParametro
     * @return @DefinicionReturn
     */
    public static ArrayList<String> getValuesPropertiesToken(String values, String tokens){        
        if(values == null)return null;
        ArrayList<String> objvalues = new ArrayList<String>();        
        StringTokenizer objTokens = new StringTokenizer(values, tokens);        
        while(objTokens.hasMoreTokens()) {
            objvalues.add(objTokens.nextToken());
        }        
        return objvalues;
    }
    
    /**
     * 
     * @param strFilePath
     * @return
     */
    public static boolean execute(String strFilePath){
        try {
            if(strFilePath == null){
                return false;
            }
            else if(strFilePath.isEmpty()){
                return false;
            }
            else if(Desktop.isDesktopSupported()){
                Desktop.getDesktop().open(new File(strFilePath));
                return true;
            }
        } catch (IOException ex) {
            Logger.getLogger(Utileria.class.getName()).log(Level.SEVERE, null, ex);
        }
        return false;
    }

    /**
     * Devuelve el Modo de Ejecución de la Aplicación.
     * @return Modo de Ejecución de la Aplicación.
     */
    public static int getExecuteMode() {
        return ExecuteMode;
    }
    
    /**
     * Devuelve el Modo de Ejecución de la Aplicación.
     * @return Modo de Ejecución de la Aplicación.
     */
    public static String getExecuteModeName(int ExecuteMode) {        
        String ExecuteModeName;
        switch(ExecuteMode){
            case Utileria.ApplicationMode:
                ExecuteModeName = "Modo Normal";
                break;
            case Utileria.AnalysisMode:
                ExecuteModeName = "Modo de Analisis de Modelos JAR";    
                break;
            case Utileria.DesignMode:
                ExecuteModeName = "Modo de Diseño GUI";    
                break;
            case Utileria.PropertiesMode:
                ExecuteModeName = "Modo de Edición de Propiedades";    
                break;
            case Utileria.SetupMode:
                ExecuteModeName = "Modo de Configuración";    
                break;   
            case Utileria.SourceCodeMode:
                ExecuteModeName = "Modo de Generación de Código Fuente";    
                break;        
            default:
                ExecuteModeName = "Modo Normal";    
        }
        return ExecuteModeName;
    }
    
    public static String getExecuteModeName() {
        return getExecuteModeName(ExecuteMode);
    }

    /**
     * Establece el Modo de Ejecución de la Aplicación.
     * @param aExecuteMode Modo de Ejecución de la Aplicación.
     */
    public static void setExecuteMode(int aExecuteMode) {        
        if(ExecuteMode != aExecuteMode){
            UtilRender.printlnConsole("Cambiando de Modo: ".concat(getExecuteModeName(ExecuteMode)).concat(" a Modo ").concat(getExecuteModeName(aExecuteMode)));
            ExecuteMode = aExecuteMode;
        }        
    }
    
    /**
     *
     * @param strPathFile
     * @return
     */
    public String getFileName(String strPathFile){
        File objFile = new File(strPathFile);
        if(objFile.exists() && (objFile.isFile())){
            return objFile.getName();
        }
        return null;
    }
    
    /**
     *
     * @param strPaquete
     * @return
     */
    public static String getStrPaqueteToFile(String strPaquete) {
        String strFilePaquete = new String(strPaquete.toCharArray());
        char c = separador.charAt(0);
        strFilePaquete = strFilePaquete.replace('.', c);
        return strFilePaquete;
    }
    
    /**
    * Creates a Zip archive. If the name of the file passed in is a
    * directory, the directory's contents will be made into a Zip file.
    * @param fileName
    * @throws IOException 
    * @throws FileNotFoundException  
    */
   public static void makeZip(String fileName) throws IOException, FileNotFoundException{
       File file = new File(fileName + ".zip");
       ZipOutputStream zos;
       zos = new ZipOutputStream(new FileOutputStream(file));
       //Call recursion.
       recurseFiles(zos, file);
       //We are done adding entries to the zip archive,
       //so close the Zip output stream.
       zos.close();
   }

   /**
    * Recurses down a directory and its subdirectories to look for
    * files to add to the Zip. If the current file being looked at
    * is not a directory, the method adds it to the Zip file.
    */
   private static void recurseFiles(ZipOutputStream zos, File file) throws IOException, FileNotFoundException{
       if (file.isDirectory()) {
           //Create an array with all of the files and subdirectories         
           //of the current directory.
           String[] fileNames = file.list();
           if (fileNames != null) {
               //Recursively add each array entry to make sure that we get
               //subdirectories as well as normal files in the directory.
               for (int i=0; i< fileNames.length; i++){ 
                   recurseFiles(zos, new File(file, fileNames[i]));
               }
           }
       }
       //Otherwise, a file so add it as an entry to the Zip file.      
       else {
           byte[] buf = new byte[1024];
           int len;
           //Create a new Zip entry with the file's name.         
           ZipEntry zipEntry = new ZipEntry(file.toString());
           //Create a buffered input stream out of the file         
           //we're trying to add into the Zip archive.         
           FileInputStream fin = new FileInputStream(file);
           BufferedInputStream in = new BufferedInputStream(fin);
           zos.putNextEntry(zipEntry);
           //Read bytes from the file and write into the Zip archive.         
           while ((len = in.read(buf)) >= 0) {
               zos.write(buf, 0, len);
           }
           //Close the input stream.         
           in.close();
           //Close this entry in the Zip stream.         
           zos.closeEntry();
       }
   }
   
   public static InternalFrameAdapter getSetModeAppInternalFrame(final int ModeApplication){
       return new InternalFrameAdapter() {
           @Override
           public void internalFrameOpened(InternalFrameEvent  e) {
               Utileria.setExecuteMode(ModeApplication);
           }
           @Override
           public void internalFrameClosed(InternalFrameEvent  e) {
               Utileria.setExecuteMode(Utileria.ApplicationMode);
           }
       };
   }
}

